# 作业：
# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
def odd_number(array):
    result = []
    for i in range(len(array)):
        if i%2!=0:
            result.append(array[i])
    return result
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
def istype(container):
    if isinstance(container,list):
        if len(container) > 5:
            print(f"传入的列表：{container}长度大于5")
        else:
            print(f"传入的列表：{container}长度小于或者等于5")
    elif isinstance(container,tuple):
        if len(container) > 5:
            print(f"传入的元组：{container}长度大于5")
        else:
            print(f"传入的元组：{container}长度小于或者等于5")
    elif isinstance(container,str):
        if len(container) > 5:
            print(f"传入的字符串：{container}长度大于5")
        else:
            print(f"传入的字符串：{container}长度小于或者等于5")
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
def isstring(result):
    zimu = 0
    num = 0
    space = 0
    other = 0
    for i in result:
        if i >="a" and i <='z' or i >='A' and i <='Z':
            zimu+=1
        elif i in "0123456789":
            num+=1
        elif i == " ":
            space+=1
        else:
            other+=1
    return f"字母有{zimu}个，数字有{num}个，空格有{space}个，其他内容有{other}个"

# 4、写函数,接收两个数字参数,返回较大的那个数字
def judge(a,b):
    if a > b:
        return a
    else:
        return b
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
def cacluate(*args):
    return args
# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def ReturnsTuple(a:str):
    capital_letter = 0
    lower_letter = 0
    for i in a:
        if i >='a' and i<='z':
            lower_letter+=1
        elif i >='A' and i<='Z':
            capital_letter +=1
    return capital_letter,lower_letter

# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
def ReturnList(arraylist:list,K:int):
    ara = arraylist[:K]
    ara_ = ara[::-1]
    arb = arraylist[K:]
    arb_ = arb[::-1]
    result = ara_ + arb_
    return result

# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def Calculated_Sum(x,n):
    a = x
    sum = 0
    # while n>0:
    #     sum += x
    #     x = x*10+a
    #     n-=1
    for i in range(n):
        sum +=x
        x = x*10 +a
    return sum
# print(Calculated_Sum(3,5)) # 3+33+333+3333+33333
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
def stu_info(name:str,sex:str,age:int,address:str):
    return f"姓名是：{name}，性别是：{sex}，年龄：{age}，地址：{address}"

# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def num_sum(*args):
    return sum(args)
# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def Iterated_object(*args,**kwargs):
    print(args)
    print(kwargs)
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def Processing_list(arrayList:list):
    str1 = ""
    for i in arrayList:
        if i == arrayList[-1]:
            str1 += str(i)
        else:
            str1+=str(i) + "_"
    return str1

# print(Processing_list([1, 2, 3]))
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
def factorial(args):
    result = 1
    for i in range(1,args+1):
        result*=i
    return result
# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def Poker_list():
    design_and_colour_list = ['梅花','方片','红桃','黑桃']
    result = []
    for i in design_and_colour_list:
        for j in range(2,11):
            result.append((i,j)) # 2~10
    BringPeople_Poker = ['J','Q','K','A']
    for i in design_and_colour_list:
        for j in BringPeople_Poker:
            result.append((i,j))
    return result

# print(Poker_list())

# 15、编写函数，求1+2+3+…N的和
def num_sum1(n):
    sum = 0
    for i in range(1,n+1):
        sum +=i
    return sum
# 16、编写一个函数，求多个数中的最大值
def max_num(*args):
    max_num = args[0]
    for i in args:
        if max_num < i:
            max_num = i
    return max_num
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def newstr(str1:str):
    new_str = ""
    for i in str1:
        if i >='a' and i <='z' or i >='A' and i <='Z':
            new_str +=i
    return new_str

# 18、写一个函数，求多个数的平均值
def average_value(*args):
    return sum(args) / len(args)

# 19、写一个自己的len函数，统计指定序列中元素的个数
def element_count(array):
    num = 0
    for i in array:
        num +=1
    return f"个数为：{num}"



# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
def newlist(list1:list):
    result = []
    for i in range(len(list1)):
        if i %2!=0:
            result.append(list1[i])
    return result
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
def narcissistic_number():
    for i in range(100,1000):
        if int(str(i)[0])**3 + int(str(i)[1])**3 + int(str(i)[2])**3 == i:
            print(i,end="\t")
# narcissistic_number()
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
def List_Sort(list1:list):
    list2 = []
    if len(list1) >=100:
        list1 = list1[:100]
    for i in list1:
        if i >=100:
            continue
        else:
            list2.append(i)
    list2 = list(set(list2))
    list2.sort(reverse=True)
    return list2
# print(List_Sort([4,4,4,4,488,99,8,5,858888,5]))

# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
def getLength(container):
    if type(container) == str:
        print(f"是字符串，长度为：{len(container)}")
    elif type(container) == int:
        print(f"是整数，长度为：{len(str(container))}")
    elif type(container) == list:
        print(f"是列表，长度为：{len(container)}")
    elif type(container) == dict:
        print(f"是字典，长度为：{len(container)}")
    elif type(container) == set:
        print(f"是集合，长度为：{len(container)}")
    elif type(container) == tuple:
        print(f"是元组，长度为：{len(container)}")
# 24、定义函数 generateNum( )
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
def moreThan(num):
    if num >1500:
        print("大于1500")
    elif num == 1500:
        print("等于1500")
    elif num <1500:
        print("小于1500")

# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
def Sum_of_squares(a,b):
    sum = 0
    for i in range(a,b+1):
        sum +=i**2
    return sum
# print(Sum_of_squares(2,5)) # 2*2+3*3+4*4+5*5



# 27、写函数，检查传入字典的每一个value长度，如果大于2，那么仅保留前两个长度的内容， 并将新内容返回给调用者
def check_dict(dict1:dict):
    for key,value in dict1.items():
        if len(str(value)) > 2:
            dict1[key] = str(value)[:2]
    return dict1
# print(check_dict({"姓名":"关博文","年龄":181}))

#  28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
def Object_judgment(container):
    if isinstance(container,list):
        if container:
            print("传入的是列表，不为空")
        else:
            print("传入的是列表，空的")
    elif isinstance(container,str):
        if container:
            print("传入的是字符串，不为空")
        else:
            print("传入的是字符串，空的")
    elif isinstance(container,tuple):
        if container:
            print("传入的是元组，不为空")
        else:
            print("空的")
# Object_judgment([1,])


# 29、编写自定义函数，完成一个简单的减法运算函数
def counter(a,b):
    return a-b
# 30、编写自定义函数，可以输出自己的名字即可。
def self_defining_function(name):
    print("大家好！")
    print("\t\t我的名字是：")
    print(f"\t\t\t\t {name}")
# self_defining_function("关博文")
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
#
#  当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
#
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
#
# 1 代表剪刀 2 代表石头 3 代表布
def defining_function():
    import random
    user_score = 100
    computer_score = 100
    while True:
        user = int(input("请输入石头剪刀布：1，2，3"))
        computer = random.randint(1,3)
        if user_score ==0 :
            print("游戏结算")
            print("玩家失败！电脑胜利！")
            break
        if computer ==0:
            print("游戏结算")
            print("电脑胜利！玩家失败！")
            break
        if user == 1 and computer == 1:
            print("平局！玩家和电脑出的都是剪刀！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
        elif user == 1 and computer == 2 :
            print("玩家出的是剪刀，电脑出的都是石头！ ")
            print("电脑胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score +=10
            user_score -=10
        elif user == 1 and computer == 3:
            print("玩家出的是剪刀，电脑出的是布！")
            print("玩家胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score-=10
            user_score+=10
        elif user == 2 and computer == 1:
            print("玩家出的是石头，电脑出的是剪刀！")
            print("玩家胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score -=10
            user_score+=10
        elif user == 2 and computer ==2:
            print("平局！玩家出的是石头，电脑出的是石头！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
        elif user == 2 and computer ==3:
            print("玩家出的是石头，电脑出的是布！")
            print("电脑胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score +=10
            user_score -=10
        elif user ==3 and computer ==1:
            print("玩家出的是布，电脑出的是剪刀！")
            print("电脑胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score +=10
            user_score -=10
        elif user == 3 and computer==2:
            print("玩家出的是布，电脑出的是石头！")
            print("玩家胜利！")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
            computer_score -=10
            user_score+=10
        elif user ==3 and computer == 3:
            print("玩家出的是布，电脑出的是布！")
            print("平局")
            print(f"玩家还有：{user_score}分数")
            print(f"电脑还有：{computer_score}分数")
# defining_function()

# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
def Reverse_string(str1:str):
    str2 = str1[::-1]
    return str2
# 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
def even_number(list1:list):
    newlist = []
    for i in list1:
        if i%2==0:
            newlist.append(i)
    return newlist

# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
def strlist(list1:list):
    len_max_str = ""
    for i in list1:
        if len(len_max_str) < len(i):
            len_max_str = i
    return len_max_str
# print(strlist(['asdsa','asd','aasdasdas']))

# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
def numlist(list1:list):
    sum = 0
    for i in list1:
        sum += i**2
    return sum



# 36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
def capital_letter(str1:str):
    str_list = str1.split(" ")
    str2 = ""
    for i in str_list:
        str2+= i.capitalize() + " "
    return str2


# print(capital_letter("sas asd"))
# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
def Intersection_lists(lista,listb):
    result = []
    for i in range(len(lista)):
        for j in range(i):
            if lista[i] == listb[j]:
                result.append(lista[i])
    return result
# print(Intersection_lists([100, 200, 300, 454], [454, 789, 125, 46]))


#  38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市
def enroll(name,sex,age,city):
    print(f"学生姓名：{name}，学生性别：{sex}，学生年龄：{age}，学生所在城市：{city}")

